Systems and methods for providing an instant communication channel within integrated development environments

ABSTRACT

A method and system may be provided for recording discussions about computer code in an integrated development environment (“IDE”). In some aspects, a communication channel is integrated with an IDE. Communications and discussions may be tracked and linked with specific code sections.

BACKGROUND

Conventional systems for software development incorporate manyenhancements to facilitate the development of code, updates, and codemodifications. A variety of integrated development environments (“IDE”)exist to provide the necessary architecture to organize code developmenttasks, as well as manage distribution of those tasks across developmentgroups. Unfortunately, coordination of work remains a significantchallenge. The need for merging and reconciliation of code changesremains a significant stumbling block, causing inconsistencies andinternal conflict within developed code.

SUMMARY

It is realized that the lack of record beyond tracked changes in theIDE, including for example, the lack of record of discussions aboutspecific problems in the code, specific issues being resolved, etc.,leads to increased issues with code divergence, conflict, and errors.According to various aspects, many of the issues with conventional IDEsand code development in general can be resolved with an integratedcommunication channel. According to another aspect, all communicationsand discussions can be tracked and linked with specific code sections(e.g., line, lines, code file, code tree elements, etc.). Thus, anyidentified problem, issues and/or planned resolution can be readilyaccessible to all the developers in a group. For example, based onlinking discussions and communications to specific code as the code isbeing development, makes the collective knowledge of the developmentcycle accessible to all subsequent reviewers.

According to one embodiment, a real time communication channel isintegrated into an IDE application as a plugin executable. The pluginexecutable can be configured to update an IDE application to display acommunication stream alongside of code editing windows or displays. Inone example, a user installs the plugin into their IDE application andactivates it via selection in the user interface (“UI”) or by selectionof special key or keys. Once activated, the plugin is visualized as acommunication panel appearing adjacent to code editor displays. Thecommunication panel provides a real time chat stream between users(e.g., developers). The real time communication stream also provides areal time activity screen. For example, users receive communications andalso notifications of activity occurring within the code beingdeveloped. According to another example, the activity notificationprovides a direct link to explore the changes, modifications, or updatesassociated with notification.

According to another aspect the system can be configured to dynamicallyidentify and link messaging, message threads, and/or any communicationchannel to select segments of code. In further aspects, the system isconfigured to dynamically adjust the definition of the code segmentsthat the respective messages are tied to. In one example, a particularcode segment (e.g., group of code lines) could be lifted completely fromone source file and moved to another. Without dynamic tracking of thecode segment, the original message thread tied to the location of theoriginal code segment would be orphaned and ultimately lost. This is afailure of many conventional message tracking systems, which variousembodiments discussed herein resolve. Various examples of the systemprovide functionality not enabled by conventional approaches and/orconventional computer systems.

In one example, the system implements dynamic machine leaning algorithmsthat enable the system to automatically identify changes within a codesegment (e.g., expansion of a method or named function to a greaternumber of code lines, changes in numbers of line of code, etc.). Machinelearning can analyze code to develop matching protocols (e.g., captureand match on method names, variable name, specific code snippets (e.g.,function calls, wrappers, etc.)) that can run in background to identifymoved code, new locations, and/or re-introduced code.

The system is also configured to use changes within code segments toupdate metadata on the code segment. For example, the system analyzeschanges so that an expanded code segment (e.g., lines 10-25 from lines10-20) are linked to a message thread about that code segment. In oneexample, an algorithm is implemented on the system to analyze content ofrespective message threads and extract information for updating metadatalinks to message threads (e.g., “I added code lines 12-15 to method(xxxxx) to fix the locking problem). The system automatically increasesthe linked code segment definition by the added lines. In otherembodiments, the system can implement monitoring algorithms (alone or inaddition to other detection algorithms) that identify changes to codesegments as they are made, and identifies changes that are used toupdate metadata linked messages, communications, and/or threads.

In various embodiments, the metadata on the respective code segments arestored separately from the code, code revision, and/or source files. Insome examples, the separately stored metadata can be retained for thelife of the software project, enabling future use of the metadata,context information, matching information, etc. In one example, thisenables the system to identify and match even on deleted code tore-capture and leverage prior messaging and development context.

In yet other embodiments, older versions of code can be linked to thenewest and most useful message threads. Often old code is needed todiagnose or test for issues in newer versions. In other alternatives,older versions of code may represent a more stable versions. Often suchreversal to old versions comes with significant sacrifice (e.g., any newdevelopments fixes, etc.) and may include re-introduction of longforgotten bugs. Metadata records of the messages and communicationbetween developer can not only identify such issued but retain thespecific fixes implemented to resolve. In some circumstances, it couldbe the fixes themselves that resulting in the new programs instability,but without the linkage between current message thread and especiallyold versions of code—developers are provided no capability to re-captureprior development context in various conventional systems.

Still other aspects, embodiments, and advantages of these exemplaryaspects and embodiments, are discussed in detail below. Any embodimentdisclosed herein may be combined with any other embodiment in any mannerconsistent with at least one of the objects, aims, and needs disclosedherein, and references to “an embodiment,” “some embodiments.” “analternate embodiment.” “various embodiments.” “one embodiment” or thelike are not necessarily mutually exclusive and are intended to indicatethat a particular feature, structure, or characteristic described inconnection with the embodiment may be included in at least oneembodiment. The appearances of such terms herein are not necessarily allreferring to the same embodiment. The accompanying drawings are includedto provide illustration and a further understanding of the variousaspects and embodiments, and are incorporated in and constitute a partof this specification. The drawings, together with the remainder of thespecification, serve to explain principles and operations of thedescribed and claimed aspects and embodiments.

BRIEF DESCRIPTION OF THE FIGURES

Various aspects of at least one embodiment are discussed below withreference to the accompanying figures, which are not intended to bedrawn to scale. Where technical features in the figures, detaileddescription or any claim are followed by reference signs, the referencesigns have been included for the sole purpose of increasing theintelligibility of the figures, detailed description, and claims.Accordingly, neither the reference signs nor their absence are intendedto have any limiting effect on the scope of any claim elements. In thefigures, each identical or nearly identical component that isillustrated in various figures is represented by a like numeral. Forpurposes of clarity, not every component may be labeled in every figure.The figures are provided for the purposes of illustration andexplanation and are not intended as a definition of the limits of theinvention. In the figures:

FIG. 1 is an example screen capture of a user interface (“UI”),according to one embodiment;

FIGS. 2A-B are screen captures of an example UI, according to oneembodiment;

FIGS. 3-6 are example screen captures of an example UI, according to oneembodiment;

FIGS. 7A-B are example screen captures of an example UI, according toone embodiment;

FIGS. 8A-8B are example screen captures of an example UI, according toone embodiment;

FIG. 9 is an example screen capture of an example UI, according to oneembodiment;

FIG. 10 is a is a block diagram of a communication system for providinga real-time communication channel in a software development environment,according to one embodiment;

FIG. 11 is an example process flow for building code associated messagestreams, according to one embodiment;

FIG. 12 is a block diagram of a special purpose computer system,according to one embodiment;

FIGS. 13-16 are example screen captures of an example UI, according toone embodiment; and

FIG. 17 is an example process flow for determining one or moredifferences between live copies of a codeblock from different users,according to one embodiment.

DETAILED DESCRIPTION

Stated broadly various aspects describe the integration of acommunication channel into source code development environments. Thesource code development environments may also incorporate versioncontrol systems or services to facilitate code development. In someembodiments, a real time communication channel is integrated into an IDEapplication. The integration may be based on a plugin or extension tothe IDE environment. In further embodiments, the real time communicationchannel is configured to display a communication stream alongside ofcode editing windows or displays. In one example, a user installs theplugin into their IDE application and activates it via selection in theuser interface (“UI”) or by selection of special key or keys. Onceactivated, the communication panel is configured to appear adjacent tocode editor displays and link user communications to specific portionsof the code, code tree, or coded functions, among other options. Thecommunication panel provides a real time chat stream between users. Thereal time communication stream also provides information on code relatedactivity in real time. For example, users receive communications andalso notifications of activity occurring within the code beingdeveloped. According to another example, the activity notificationsprovide a direct link to code that enables users to explore the changes,modifications, or updates associated with notification.

Examples of the methods and systems discussed herein are not limited inapplication to the details of construction and the arrangement ofcomponents set forth in the following description or illustrated in theaccompanying drawings. The methods and systems are capable ofimplementation in other embodiments and of being practiced or of beingcarried out in various ways. Examples of specific implementations areprovided herein for illustrative purposes only and are not intended tobe limiting. In particular, acts, components, elements and featuresdiscussed in connection with any one or more examples are not intendedto be excluded from a similar role in any other examples.

Also, the phraseology and terminology used herein is for the purpose ofdescription and should not be regarded as limiting. Any references toexamples, embodiments, components, elements or acts of the systems andmethods herein referred to in the singular may also embrace embodimentsincluding a plurality, and any references in plural to any embodiment,component, element or act herein may also embrace embodiments includingonly a singularity. References in the singular or plural form are notintended to limit the presently disclosed systems or methods, theircomponents, acts, or elements. The use herein of “including,”“comprising,” “having,” “containing,” “involving,” and variationsthereof is meant to encompass the items listed thereafter andequivalents thereof as well as additional items. References to “or” maybe construed as inclusive so that any terms described using “or” mayindicate any of a single, more than one, any combination of, and all ofthe described terms.

FIG. 1 is a screen capture of an example user interface (UI), showing anintegrated development environment 100. The IDE 100 includes anavigation panel 102 organizing source code files, configuration files,libraries, etc. Once files are selected in the navigation panel 102, theediting panel 104 is configured to display the associated file/code forediting in the UI. FIG. 2 is a screen capture of an example UI 200,showing the IDE with the communication plugin enabled. For example, oncea user installs the plugin onto their IDE application (e.g., ATOM) areal time communication stream is configured to be displayed in acommunication panel 206. In some examples, the plugin must be activatedby the user, by selection in the UI or selection of special keys, andonce active display 206 appears in the UI.

Messages (e.g., 208, 210, and 212) are displayed chronologically in thecommunication stream associated with a directory or file being displayedin the editing panel 204. In addition to user messages, thecommunication panel 206 is configured to display notifications (e.g.,214) associated with the file or directory being accessed (i.e.,visualized in panel 204). According to some embodiments, the integrationof the communication channel and tracking of message streams andnotifications provide significant enhancement over conventiondevelopment approached. For example, under conventional developmentapproaches the user would need to switch to a message application orservice to start a communication stream, moreover, the user would haveto determine the party with which they wish to communication which wouldrequire accessing yet another application.

According to some embodiments, creating a message to another user (e.g.,a developer) is streamlined by typing into a text input box at 216.According to another embodiment, utilizing additional features providedby the communication plugin, a user can select portions of code (e.g.,via highlighting by mouse or other pointing device) and begin a messageassociated specifically with the selected portion of code. Once selectedin the UI, the system is configured to maintain a reference to ablock/section of code in response to selection in the UI. According toone embodiment, the reference is embedded in a message and can be storedon the system and accessed when messages are displayed or read. Forexample, the references, along with a copy of the code itself, can bestored on the system or as an attachment to the message, and can beincluded as part of the message metadata.

FIG. 2B is an example user interface showing a portion of code 230selected in the editing panel 204, and an associated message beinggenerated in the communication panel 206. The system enables the user toenter text at 216, responsive to an indication the user wants to createa message regarding the highlighted code segment (e.g., right click oncode segment and select message, hot key “<cntrl> m,” etc.). At 223, thesystem displays the association between the selected code (e.g., 230)and the message being created. In some embodiments, the system isconfigured to analyze the selected code responsive to selection. Theanalyze is executed by the system to identify a recipient for themessage without requiring user identification.

For example, the system analyzes author or editor information associatedwith the selected code segment to provide a recipient for the messageautomatically (e.g., at 225 the system identifies “Larry Wall” as theauthor of the selected code). In one example, the system identifies thecode author or editor from a local repository or searches a code storagerepository (e.g., git repository) for information on an author or editorfor code identified in the user interface.

It is realized that such an integrated messaging panel and automaticdetection of responsible parties for code elements, provides significantimprovement over known development environments and communicationsystems. In the first instance, the user does not have to transition toa separate communication application (e.g., e-mail), and further unlikea conventional implementation, the user does not have to search aversion control system to identify the author or editor of the selectedcode (e.g., GIT). For example, in a conventional system using GIT, a newterminal would be needed by the user to investigate the author withGIT_history or GIT_blame (i.e., access attribution records).

According to further aspects, a system for tracking comments on sourcecode over time is provided. The system handles gracefully linkagesbetween code segments under development and message regarding those codesegment. In some examples, this is particularly challenging due tonature of software development, where code segments are dynamicallyaltered, deleted, moved, re-named, and overwritten (e.g., intentionallyor otherwise). In conventional approached, most software is developedusing a decentralized version control system (VCS) which allows eachdeveloper to have a full copy of all of the files that make up aproject.

During development periods, a developer might make several changes toseveral of these files, before sharing these changes with the rest ofthe team in something called a commit set. When the developer is donewith her work, sometimes over several days or weeks, she can share thework with the team. This commit set describes the changes to all of thefiles which have changed; adding lines, deleting lines, changing lines,adding files, renaming files, etc.

Various embodiment, (and in some examples a system/application named“CodeStream”) provide a mechanism to add a comment to a specific pointin a file, a line in a file, or a range in a file, and in furtherexample preserve that linkage across any changes (e.g., deletes,modifications, expansions, moves, re-names, etc.). In some embodiments,the comment is displayed in the development user interface like achat-like block of text that a user will enter. The comment refers to aportion of the code (typically called a codeblock or referred to as acode segment—which can be identified by code line number, for example).This codeblock might start at, for example, the beginning line 12 of afile, and go all the way to the middle of line 26. The comment refers tothat specific range, and in some examples is stored in a metadata fileproviding information on the context of the comment and including forexample the line numbers associated with the comment.

Over time, as the code changes, the system gracefully (andautomatically) handles lining the comment so that the comment stillpoints to the same codeblock (even as the code block changes). Examplesof changes include: —code could be added above the range currentlyidentified, in which case perhaps the comment now should refer to lines14-28; code removed above the range; code added within the range, inwhich case the comment now should refer to lines 12-36; code could beremoved across one of the boundaries of the range; entire codeblockcould be removed, so the comment is no longer relevant; entire codeblockcould be moved to a different part of the file, or to a different file,or to a new file

According to various embodiments, updates to code ranges can be appliedto recalculation of the appropriate range for that comment so that itapplies only to that version of the file (after the changes were made).According to various embodiments, the algorithm is configured todetermine the best way to move the range, or delete the range, or modifythe range as appropriate. The new locations and statuses of the rangewill be stored for this particular version of the file.

In yet other embodiments, over time when the file changes again, thealgorithm is executed by the system to track how the comments havemoved. In some examples, the system tracks cut and paste into new files,and updates metadata associated with comments or communications. Inother examples, the system can analyze new code changes to determine ifany previous comment or message thread match the new code—if a matchresults the linkage can be made. In yet other embodiments, the algorithmdetects changes to existing code and can analyze the prior version todetermine that the new code lines were introduced within or into themiddle of the code block—in which case the system expands the linkage tothe larger number of code lines. Further, the system can likewiserespond and update linkage in response to deletions within thecodeblock.

The messaging linkage metadata can be accessed and used to identify themost relevant messages to whatever files is being accessed in thedevelopment or version control environment. Thus, whichever version ofthe file a user loads into their editor (e.g., even an older version)the comments will refer to the best possible references within the code.

FIG. 3 is a screen capture of an example UI 300. UI 300 illustrates anexample message 301 generated in the communication panel 206. Theexample message 301 incorporates the recipient and text of a usermessage at 302. The example message 301 also includes a copy of the codesegment on which the author wishes to communicate. According to someembodiments, provide the code associated with the message improve theefficiency of the development environment over known approach. Forexample, the communication plugin provides functionality in conventionalenvironments and reduces the operations needed to be executed inconventional environment. In other examples, inclusion of the code inthe message allows the recipient to immediately understand the contextof the question, and by navigating to the identified code, the user alsohas accessed to any preceding conversation threads and/or notificationmessages associated with the code.

FIG. 4 is a screen capture of an example UI 400, where the user “LarryWall” has sent a message to the author of the code. According to oneembodiment, the new message 401 is displayed within the message panel406. Matches in the message text to code elements are displayed tovisual show the correspondence between the message text and codeelements in the UI (e.g., at 408 and 410). Text that corresponds to codeelements can be configured for selection in the UI to transition theediting panel 406 to the respective place in the code containing thesegment. Similar to the example provided in FIG. 3 (e.g., at 302 and304), the message 401 contains a visualization of the code associatedwith the message at 412.

According to some embodiments, the system is configured to identifychanges in code, and flag that information in the user interface whenconstructing a message for display. For example, at 414 a visualindicator is presented (e.g., red triangle with exclamation point) toprovide a visual indication, for example, of a code change in themessage that reflects a different version of the code being viewed bythe current user. The visual indicator can be responsive to pointerevents in the UI (e.g., mouse over, and mouse over hover, etc.). In thisexample, a mouse over and hover operation triggers the UI to display amessage “This block of code is different that your current copy.”

Clicking on the message 401 causes the system to transition to anotherview in the user interface configured to focus the user on theconversation stream associated with the code in the message. FIG. 5illustrates an example UI showing a view of the message 501 selected inthe UI displayed in a communication panel 506 with a respective messagestream, and focusing on the associated code 508 in an editing panel 504.According to some embodiments, the code change message stream providessome additional functionality. For example, the communication panelprovides options to the code author (e.g., original author, editinguser, responsible editor, etc.) to accept a proposed code change (e.g.,via selection of “Apply Patch” at 520). Other functions include “ShowDiff” at 522, which triggers the system to display a code differenceview in editing panel 504. The code difference view shows changes to thecode in markup language. The system also provides functions to copy codeat 524 and Add a Reply at 526. Selecting 526 allows the messagerecipient to continue the communication thread. For example, therecipient can ask why the change is necessary, and the subsequent answeris displayed in communication panel 504 in real time. According tovarious embodiments, the communication stream associated with the codesegments is maintain for review by later users, who are then able toreview the code changes, and through the message stream immediatelyunderstand the purpose or reason for such changes.

FIG. 6 shows an example message stream associated with a code change andmessaging back and forth between the requestor and the code author orresponsible user. The message stream can be displayed in a communicationpanel (e.g., at 606). According to some embodiments, selection of the acode change message transitions the system to a focused code reviewmessage stream (e.g., in 606). By selecting 608 the system is configuredto transition back to a general file or directory message stream (e.g.,like in FIG. 4 at 406). In further embodiments, code specific messagestreams are stored for subsequent access. For example, annotations aredisplayed in conjunction with code line numbers in editing panel 604 at610. The annotation visual elements are configured to display in allvisualizations of the code. The annotation indicator is configured totransition the system to code specific message stream views that enablethe user to review, for example, proposed code changes, messagingbetween the developers, etc.

FIG. 7A is an example screen capture of a UI showing unread messagenotification. In the space to the right of the code tree listing (e.g.,702), at column 710 a count of any unread messages associated with eachfile in the code tree is displayed. The system maintains information onnew message and a read status. In some embodiments, the system isconfigured to display an unread message notification with a count of theunread messages included in the display. The notification is presentedin association with the file and/or code to which the message pertains.In some embodiments, users are given fie grain control over theappearance of these notifications, being able to turn notifications offper file, across a directory, or for the entire code tree. FIG. 7A alsoillustrates a transition from the message stream view in FIG. 6 to themessage stream view of FIG. 7A, responsive to selection of CHANELOG.mdat 720. The transition includes a transition in the editing panel 704 toshow the code associated with the CHANELOG.md file, and thecommunication panel 706 reflects messages associated with theCHANELOG.md file. AT 730 additional unread message notifications aredisplayed. Unread notification displays can be configured to highlightmessages that are directed to a current users. For example, 730 can bedisplayed in read to bring the user's attention to the unread messagenotification that includes messages directed to the current user.Selecting 730 in the UI (e.g., clicking with a mouse and pointer)transitions the system the example UI shown in FIG. 7B.

Once the user views the messages, the unread message indicator is nolonger displayed in column 750. According to some embodiments, within amessage stream additional displays can be displayed to draw the user'sfocus to their messages. For example, at 760 an “@” indicator can bedisplay in a highly visible color (e.g., red) to bring attention to aspecific message. As discussed above, the system provides fine graincontrol over notification massages. For example, right clicking on afile in the code tree provides a menu option to mute notificationmessages. Additional options in the menu can include “bold” and “badge”which are configured to allow a user to tailor message reportinginformation/visualization on the system. According to one embodiment, asystem default is configured to display a numerical indicator showing #of new messages to the file (for example, that number of messages can bereferred to as a “Badge”—e.g. on an iPhone, the red number that appearsover the messages icon in the UI shows the user how many unread messagesthe user has across all of the user's conversations). For example, if auser wants to know that there are new messages, but does not need theadditional information on how many, the user can select “Bold” from themenu. Responsive to selection of bold the system is configured to limitUI displays of unread messages to a visual indication without the numberof unread messages. In one use case, the user can select this options inthe UI when the user wants to know that there is conversation, but doesnot want to be overwhelmed by 872 unread messages. According to anotherembodiment, a mute all (e.g., 770) option is available to turn off thedisplays associated with the communication streams for all the files inthe code tree.

FIG. 8 shows another example UI according to one embodiment that exposedversion control system (“VCS”) information captured from a versioncontrol system (e.g., GIT) integrated with the user's IDE. A VCS panel800 can be displayed on the right side of the screen above a messagestream associated with a file in the code tree shown at 802. The VCSpanel 800 is configured to display information captured by the system,that would normally require a transition to a version control systemexternal to the IDE and associated operations (e.g., GIT blame orhistory). The VCS information enables a comprehensive view of the codeand version control information to improve over convention commitprocessing in IDEs. The additional information exposed includes:contributors at 810, branch information at 812, and last editinformation at 814. In some embodiments, an edit history timeline can bedisplayed (e.g., 822) that is configured to display associated editsresponsive to selection in the timer (e.g., mouse click). The real timenature of the communication channel provide by the plug-in and/or IDEcommunication system enable further functionality akin to enhancedpresence for software developers. For example, a real time status windowcan display actions underway by other developers.

According to one embodiment, display 820 includes real time statusnotification that can covey that another user is currently editing afile (e.g., FIG. 8B 820) that the current user is working on committingtheir changes to. Further embodiments provide real time notification ofpotential merge conflicts, where another user has begun editing the samecode or code lines being reviewing for a commit (e.g., at 820—“Pendingmerge conflict with Ken Thompson”). Some embodiments of the systemmaintain change status information on lines of code and compare editingbeing executed by other users in real time. Merge conflicts areidentified by the system when other users edit the same code lines fromprior versions of the code, that another users has also edited.Providing notifications on merge conflicts as they occurring representsa significant advance over other approaches.

Selection in the VCS panel 800 of “Diff” at 830 transition the system toa difference view of the code in editing panel 804. FIG. 9 is a screencapture of an example UI 900 showing a difference view of the code at904. Selection of Blame 832 FIG. 8A transitions to a view of attributioninformation for edits. Each of the function provides additionalcapability to improve the user's capability and understanding duringcode commits. Moreover, the communication panel available in each of theviews, facilitates real time resolution of questions and/or problemsassociated with specific code. Those messages then become readilyaccessible context for later review of the same code. Each of thefunctions described with respect to the UI captures is enabled by anunderlying IDE communication system or plugin. Various embodiment areprovided as plugin extensions that integrate and leverage functionalityprovided by an existing IDE application. Some embodiments include IDEapplications architected with the communication interface and trackingfunctions built in without the need for extensions or plugins.

Shown in FIG. 10 is a block diagram of an IDE communication system 1000.According some embodiments, the IDE communication system can comprise anIDE application with communication functions built in or can comprise aplugin or extension for existing IDE applications. The system 1000 isconfigured manage communications between a user base accessing adevelopment environment. According to one embodiment, the system managescommunication while maintain associations to source code identified inthe development environment. In one example, the system enables users toselect lines of code on which to build a message. The system records theassociations to the lines of code and the composed message, and enablesa message stream between the user base tied to the lines of code. Thespecific message stream can also be linked to the source code file, andbe accessed in a higher level view of the message streams associatedwith the source code file. The system further enables transitionsbetween the focused view associated with the specific lines of code andviews of the file and associated larger message streams.

According to various embodiments, the system is configured to managemessaging functions and saved links between messages and subsets ofsource code. Further, system enables chat sessions (e.g., instantmessaging) to take place around a specific location or block of code andpermanently creates an association between source code and theconversations between users about it. According to some embodiments, therecord of the conversations can be specific and include, for example,which version/branch of the file/function/block it refers to. The systemand associated UIs can be configured to display message streamassociated with a specific version/branch of the file/function/block andcan also allow access and/or display to message streams for allversion/branches of the file/function/block or code. For example, theolder versions and associated messages can display in chronologicalorder. In other examples, options to navigate to other versions orbranches can be displayed in the UI.

According to various embodiments, the system is configured to includeindicators within displays of source code of extant conversations. Insome examples, the displays include annotation indicators displayed inconjunction with code line number displays. In other embodiments, thesystem can be configured to provide displays for Unread MessageIndicators associated with source files, for example, shown in a codetree. The system can also be configured to display different visualindicators for pending patches, at-mentions, commits, etc., in the userinterface. Selection in the UI can trigger the system to transition tothe respective code/source file/etc. to review along with any associatedmessage streams. In some embodiments, the system is configured togenerate and display a history slider inside any IDE, where the historyslider is configured to transition through a message stream associatedwith some code or function. The user can transition throughchronological message based on manipulating the history slider in theUI.

Integration into the development environment (for example using adevelopment environment engine 1002) provides a number of functions thatextend traditional implementations. In some embodiments, the system isconfigured to automatically generation addressee information andpre-fill address information in a message responsive to selection ofcode in the UI (e.g., with engine 1002). For example, the system can beconfigure to pull email addresses from any code repository, andautomatically populate the addressee in the message responsive toselection of code line(s) or code portions. In one example engine 1002can be configured to search code or code repositories (e.g., evenexternal code repositories) for associated e-mail address for authors orcode administrators and return that information to the system forautomatic messaging.

The system can also be configured to augment code review processes fordevelopment. For example, the system is configured to improve formalcode review, based on the message streams and archives of issues,resolutions, proposed changes, and commit operations. In someembodiments, the system includes a tracking engine 1006 configured toassociated code, code lines, code segments, etc. to message streamsabout them. In this manner, the system uses the messages streams andpresentation to subsequent users to implement code review as an organicby-product of strong communication within and about the code. In otherexamples, use of the communication system enhancements can reduce andeliminate the need for formal code reviews while preserving compliancewith formal code review protocol. In other words, the tracking of issueand resolution and/or code changes over time, provides the neededinformation for a formal code review process. According to oneembodiment, review of each message by subsequent users can be tracked onthe system and used to clear formal code review requirements.

According to another embodiment, the system can include a communicationengine 1004 specially configured to manage enhanced communicationfunctionality. Although in other embodiments the system can beconfigured with the same functionality without a specialized engine. Thecommunication engine is configured to enable instant messaging and/orchat between the users of the development environment. For example, thecommunication engine provides direct messaging embedded into any IDE.Further embodiments, enable channel messaging, where members are addedto a topic specific channel by a channel creator or users can addthemselves, or request additional to specific communication channels Forexample, a “bugfix” channel can be used to post bug information, andserve as a topic specific message stream that exists apart for the codebased message streams. According to various embodiments, both messagestreams can be tied to specific code and both message streams can beused to access various messages, but the channel specific streamprovides a topic organization (e.g., all bugs, backend rewrite channel(e.g., fixes specific to bank end issues), etc.) as opposed to codeline/file/function associations of other message streams.

In further embodiment, the communication engine 1004 can operate inconjunction with an interface engine 1008 to provide contextualindicator in a user interface regarding pending communication or unreadmessages. The interface engine can generate specific visualization toidentify messages to a current user or provide general notification tomessages within a message stream or channel. Further the interfaceengine and/or the communication engine can be configured to providereal-time notification of file modifications and can detect and displayreal-time events to the user base.

According to some embodiments, the interface engine 1008 can alsoreceive information from a tracking engine 1008. In one example, thetracking engine can be configured to maintain info ration on codechanges across all users. The tracking engine can be configured todetect merge conflicts that result from multiple users altering the samecode. For example, based on merge conflict information the interactionengine can be configured to display real-time notification of pendingmerge conflicts and prevent the conflict from being committed by therespective parties. The tracking engine 1006 is configured to detectreal-time conflict between two or more developers and triggernotification messages to the respective users.

Further enhancements over conventional IDE approaches include aone-click patch user interface configured to enable code patchesproduced by other developers to be automatically applied based on reviewof the code by the original code author or code administrator.Additionally, the system and/or communication engine 1004 is configuredto enable messaging and message stream tracking across multipledevelopment environments. For example, a first user operating a firstIDE application and a second user operating a second IDE application canboth develop the same code base through their respective environments,and are both given access to messages streams sent to users in eitherenvironment or between users operating in different environments.According to various embodiments, the system and/or communication engine1004 can operate as a common interface between any number of differentIDE applications, allow any number of users to select between and numberof development platforms, while still enabling the common communicationchannel and tracking functions that eliminate many of the issues withconventional IDE applications.

For example, the system is configured to add a real-time conversationstream to any type of document (e.g., a document can be a source codefile, a “word doc”, a spreadsheet, etc.) and for example, enable any oneor more of: track any communications, annotate the document (e.g.,source code file) to enable access to prior messages, auto-direct newmessages, notify users of user directed message, maintain unreadindicators within the document, among other options.

In further embodiments, the communication streams tracked by the systemare linked to code line and/or function descriptions (e.g., the systemis configure to recognize that selected code lines in the UI are part ofa given function (e.g., system is configured to search preceding or postlines for method calls, class definitions, start functions characters,etc.). That information is linked to the given messages and/or messagesstreams by the system automatically, so the associations and/orfunctions can be searched directly to retrieve the associated messageswithin particular code repository.

In further embodiments, the system manages message stream so thatresponsive to selection in the user interface the system is configuredto jump to points in a conversation stream based on commit. In oneexample, commit operations are tracked by the tracking engine 1006, andare accessible based on a commit operation, code line, etc. In furtherembodiment, the system and/or tracking engine stores information oncommit history to enable automatic generation of review teams. Forexample, the system is configured to automatically determine a reviewteam based on commit history queried from a VCS application or service.Further the system can build a review team from any users who hadengaged in message streams associated with code commits on specificfiles, functions, code lines, etc. In one example, the systemauto-assembles teams based on VCS commit history, where the team isdefined by member of matching discussion groups. The system is alsoconfigured to facilitate code review inside the IDE, furtherfacilitating code review operations.

As discussed above, various embodiments of the communication system caninclude a variety of engines configured to perform specific tasks withinthe system, however, various embodiments are configured to perform thesame or similar functions without need of instantiating the respectivecomponents discussed above.

FIG. 11 is an example process flow 1100 for building code associatedmessage streams. According to one embodiment, process 1100 begins withselection of one or more code lines in a user interface at 1102 In otherexamples, the process can begin with selection of any document orportion of a document in an editing panel of an IDE. Responsive toselection of the code lines, a message interface can be displayed at1104. In some embodiments, the selected code lines and/or associatedcode file can be used to identify an author of the code, a last editorof the code, or a responsible party (e.g., code administrator) for theselected code at 1106. The identified user is then displayed in themessaging interface as an auto-generated recipient of a message aboutthe selected code. Once any message text is received, the process 1100continues at 1108 with communication to the message to the specifiedrecipients. In some embodiments, messages are communicated to users onother IDE applications, and can optionally be indicated to other usersvia unread message notifications. At 1110, the message is stored withassociations to any one or more of the selected code, code lines, codefunctions, or code file. Subsequent access to the same code file willdisplay any messages streams associated with the code file. Selectionwithin the message stream can be trigger a transition by the system to aview of code specific message stream. In another example, selection ofcode in the editing panel can transition a communication panel to a codespecific view of a message stream.

Process 1100 is illustrated as an example process flow. In otherembodiments, the various steps illustrated can be executed together, orones of the various steps can be omitted or executed as part of otherprocesses.

The various functions, processes, and/or pseudo code described hereincan be configured to be executed on the systems shown by way of examplein FIG. 10 . The systems and/or system components shown can be speciallyconfigured to execute the processes and/or functions described. Variousaspects and functions described herein, in accord with aspects of thepresent invention, may be implemented as specially configured hardware,software, or a combination of hardware and software on one or morespecially configured computer systems. Additionally, aspects in accordwith the present invention may be located on a single speciallyconfigured computer system or may be distributed among one or morespecially configured computer systems connected to one or morecommunication networks.

For example, various aspects, components, and functions (e.g.,auto-generate recipient, link messages and code lines, automaticallybuild channel and/or team, code review functions, generate unreadmessage notification, navigate to code specific message streams, etc.)may be distributed among one or more special purpose computer systemsconfigured to provide a service to one or more client computers, mobiledevice, or to perform an overall task as part of a distributed system.Additionally, aspects may be performed on a client-server or multi-tiersystem that includes components or engines distributed among one or moreserver systems that perform various functions. Consequently, examplesare not limited to executing on any particular system or group ofsystems. Further, aspects and functions may be implemented in software,hardware or firmware, or any combination thereof. Thus, aspects andfunctions may be implemented within methods, acts, systems, systemelements and components using a variety of hardware and softwareconfigurations, and examples are not limited to any particulardistributed architecture, network, or communication protocol.

Referring to FIG. 12 , there is illustrated a block diagram of adistributed special purpose computer system 1200, in which variousaspects and functions are practiced (e.g., including a replicationcomponent (e.g., captures executed write operations and distributes tonodes hosting the same copy of data), a configuration component (e.g.,enables arbiter participation in either or both data commitment andprimary election), an election component (e.g., triggers electionprotocols in response to primary failure), among other options). Asshown, the distributed computer system 1200 includes one more specialpurpose computer systems that exchange information. More specifically,the distributed computer system 1200 includes computer systems 1202,1204 and 1206. As shown, the computer systems 1202, 1204 and 1206 areinterconnected by, and may exchange data through, a communicationnetwork 1208. For example, a segment of a distributed database can beimplemented on 1202, which can communicate with other systems (e.g.,1204 and 1206), which host other or remaining portions of the system,message data, and/or copies of the linked message data.

In some embodiments, the network 1208 may include any communicationnetwork through which computer systems may exchange data. To exchangedata using the network 1208, the computer systems 1202, 1204 and 1206and the network 1208 may use various methods, protocols and standards,including, among others, TCP/IP, or other communication standard, andmay include secure communication protocols VPN, IPsec, etc. To ensuredata transfer is secure, the computer systems 1202, 1204 and 1206 maytransmit data via the network 1208 using a variety of security measuresincluding, for example, TLS. SSL or VPN or other standard. While thedistributed computer system 1200 illustrates three networked computersystems, the distributed computer system 1200 is not so limited and mayinclude any number of computer systems and computing devices, networkedusing any medium and communication protocol.

As illustrated in FIG. 12 , the special purpose computer system 1202includes a processor 1210, a memory 1212, a bus 1214, an interface 1216and data storage 1218 and further includes any one or more of thecomponent discussed above to implement at least some of the aspects,functions and processes disclosed herein, as either a stand-alone systemor part of a distributed system. In some embodiments, the processor 1210performs a series of instructions that result in manipulated data. Theprocessor 1210 may be any type of processor, multiprocessor orcontroller. The processor 1210 is connected to other system components,including one or more memory devices 1212, by the bus 1214.

The memory 1212 stores programs and data during operation of thecomputer system 1202. Thus, the memory 1212 may be a relatively highperformance, volatile, random access memory such as a dynamic randomaccess memory (DRAM) or static memory (SRAM) or other standard. However,the memory 1212 may include any device for storing data, such as a diskdrive, hard drive, or other non-volatile storage device. Variousexamples may organize the memory 1212 into particularized and, in somecases, unique structures to perform the functions disclosed herein.These data structures may be sized and organized to store values forparticular to specific database architectures and specific data types,and in particular, may include standardize formats for organizing andmanaging data storage.

Components of the computer system 1202 are coupled by an interconnectionelement such as the bus 1214. The bus 1214 may include one or morephysical busses, for example, busses between components that areintegrated within the same machine, but may include any communicationcoupling between system elements including specialized or standardcomputing bus technologies such as IDE. SCSI, PCI and InfiniBand orother standard. The bus 1214 enables communications, such as data andinstructions, to be exchanged between system components of the computersystem 1202.

The computer system 1202 also includes one or more interface devices1216 such as input devices, output devices and combination input/outputdevices. Interface devices may receive input or provide output. Moreparticularly, output devices may render information for externalpresentation. Input devices may accept information from externalsources. Examples of interface devices include keyboards, mouse devices,microphones, touch screens, printing devices, display screens, speakers,network interface cards, etc. Interface devices allow the computersystem 1202 to exchange information and to communicate with externalentities, such as users, vendors, and other systems.

The data storage 1218 includes a computer readable and writeablenonvolatile, or non-transitory, data storage medium in whichinstructions are stored that define a program or other object that isexecuted by the processor 1210. The data storage 1218 also may includeinformation that is recorded, on or in, the medium, and that isprocessed by the processor 1210 during execution of the program. Morespecifically, the information may be stored in one or more datastructures specifically configured to conserve storage space or increasedata exchange performance.

The instructions stored in the data storage may be persistently storedas encoded signals, and the instructions may cause the processor 1210 toperform any of the functions described herein. The medium may be, forexample, optical disk, magnetic disk or flash memory, among otheroptions. In operation, the processor 1210 or some other controllercauses data to be read from the nonvolatile recording medium intoanother memory, such as the memory 1212, that allows for faster accessto the information by the processor 1210 than does the storage mediumincluded in the data storage 1218. The memory may be located in the datastorage 1218 or in the memory 1212, however, the processor 1210manipulates the data within the memory, and then copies the data to thestorage medium associated with the data storage 1218 after processing iscompleted. A variety of components may manage data movement between thestorage medium and other memory elements and examples are not limited toparticular data management components. Further, examples are not limitedto a particular memory system or data storage system.

Although the computer system 1202 is shown by way of example as one typeof computer system upon which various aspects and functions may bepracticed, aspects and functions are not limited to being implemented onthe computer system 1202 as shown in FIG. 12 . Various aspects andfunctions may be practiced on one or more specially configured computershaving different architectures or components than that shown in FIG. 12which can be modified to include the specially purpose components and/orfunctions discussed. For instance, the computer system 1202 may includespecially programmed, special-purpose hardware, such as anapplication-specific integrated circuit (ASIC) tailored to perform anyone or more operations disclosed herein (e.g., validating receivedoperations, routing write operations, replicating operations, amongother examples). While another example may perform the same function(s)using a grid of several computing devices running MAC OS System X withMotorola PowerPC processors and several specialized computing devicesrunning proprietary hardware and operating systems.

The computer system 1202 may be a computer system including an operatingsystem that manages at least a portion of the hardware elements includedin the computer system 1202. Additionally, various aspects and functionsmay be implemented in a non-programmed environment, for example,documents created in HTML, XML or other format that, when viewed in awindow of a browser program, can render aspects of a graphical-userinterface or perform other functions.

FIG. 13 illustrates an example UI 1300 showing a view of message 1301selected in the UI displayed in a communication panel 1306 with arespective message stream, and focusing on the unmodified, original code1308 in an editing panel 1304. According to some embodiments, the systemexecuting the UI, or the system in communication with another systemexecuting the UI, identifies a recipient of the message 1301 in themessage stream and annotates in the message stream the recipient withrespect to the message 1301 (e.g., the system identifies and annotates“Larry Wall” as the author of the message 1301). According to someembodiments, the system distinguishes between a target user for themessage 1301 and another user mentioned in the message 1301 and selectsthe target user as the recipient of the message 1301. For example, ifanother user is mentioned in the body of the message 1301, that user isnot selected as the recipient of the message 1301. Instead the recipientselected or targeted by user “Larry Wall” is selected as the recipientof the message 1301. According to some embodiments, the systemdetermines whether the message 1301 relates to a special codeblock(e.g., an altered codeblock, an orphaned codeblock, etc.). If themessage 1301 is determined to relate to a special codeblock, the systemis configured to visually distinguish the message 1301 in thecommunication panel 1306 to indicate this relationship to the user.

According to some embodiments, if the system receives a modification ofthe original code 1308 in the editing panel 1304 (e.g., additional codeadded, deleted, renumbered, moved), the system stores metadata forpreserving communication thread linkage between the modified code andthe respective message stream associated with the original code 1308.The modification may be received in the message 1301 or a user of thesystem may directly enter the modification into editing panel 1304.According to some embodiments, the system stores, in metadata relatingto the original code 1308, a commit identification of the code in theediting panel 1304 and/or a commit identification of the modified code(e.g., when the modified code is included in a code repository, e.g.,git repository). For example, the system may store the commitidentification to help keep track of changes to the original code 1308across different versions of the code stored in a code repository.

According to some embodiments, the system determines whether themodification comprises deletion of a portion or all of the original code1308 in the editing panel 1304. In response to determining that themodification comprises such a deletion, the system is configured tovisually indicate, in the editing panel 1304, a portion of the editingpanel 1304 corresponding to the deleted code. For example, such a visualindication may assist the user in identifying that code has been deletedand/or identifying code that came before and after the deleted code.Additionally or alternatively, the system may store, in metadatarelating to the original code 1308, one or more messages in the messagestream, e.g., the message 1301, corresponding to the deleted code. Forexample, the system may store this information in the metadata to keeptrack of changes to the original code 1308 across different versions ofthe code stored in a code repository. Another user reading the messagesstored in the metadata may be provided with appropriate context for thechanges made across the different versions of the code.

According to some embodiments, the system dynamically monitors themessage stream for presence of code. For example, the user may receive amessage that includes code, e.g., the code in the message 1301. Thesystem may detect the presence of code based on detecting one or morespecial characters, one or more variable names, or another suitableindicator of presence of code in the message. For example, the systemmay detect the presence of code based on detecting one or more leadingspaces or one or more leading tabs at the beginning of a line in thereceived message. In response to detecting code in a message in themessage stream, the system may determine whether there is anycorresponding code in the editing panel 1304. For example, the systemmay determine that the code in the message 1301 corresponds to theoriginal code 1308 in the editing panel 1304. The system may execute aheuristic-based search algorithm to identify the corresponding code,e.g., the original code 1308, based on the code detected in the message,e.g., the code in the message 1301.

According to some embodiments, the system is configured to provide oneor more options for receiving updated or modified code, for example,through the message panel. For example, the system may be configured toprovide an option to the user (e.g., original author, editing user,responsible editor, viewing user, etc.) to accept the code changeproposed in the message (e.g., 1301). For example, the system candisplay a set of selection options within the messaging panel responsiveto receiving modified code (e.g., via selection of “Apply Patch” at1324). Other options may include a “Show Diff” function at 1322.According to one embodiment, the “Show Diff” function is configured totrigger the system to display a code difference view in editing panel1304, between the current version of the code being viewed by a givenuser and the code as it would appear if the proposed modifications areexecuted. According to one example, the code difference view isconfigured to show changes to the code in markup language. In otherexamples, the system is configured to provide an option for a copy codefunction at 1326. Selecting 1326 may store the code from the message1301 in temporary memory, e.g., a clipboard, for later retrieval by theuser. The system may provide an option for a warp function at 1320. Thewarp function allows the user or message recipient to view the editingpanel for another user, e.g., the sender of message 1301. For example,the sender of message 1301 may view his version of the code in hisediting panel. The sender may make modifications to his version of thecode. The sender may subsequently send message 1301 including proposedmodifications that correspond to his modifications to the code. The useror message recipient receiving message 1301 may select 1320 to view thesender's editing panel and observe the sender's modified code. The useror message recipient may select the option to view the sender's editingpanel because the user may desire to view the sender's modified codeprior to applying the proposed modifications from message 1301 to hisown version of the code. According to one embodiment, selecting 1320 mayallow the user or message recipient to observe another user's editingpanel and view the other user make modifications to his version of thecode in real time. The user may optionally send a message to the otheruser with feedback on the modifications as the other user makes them.The other user may alter his modifications based on the feedback fromthe user. In this manner, the warp function may allow the two users tocollaborate on the modifications to the code before they are finalized.According to one embodiment, selecting 1320 may allow the user ormessage recipient to compare his version of the code with the messagesender's version of the code. For example, the user or message recipientmay view his version of the code in one half of the display and themessage sender's code in the other half of the display.

According to one embodiment, the user or message recipient does notmodify the original code in his editing panel. The message sendermodifies the original code in his editing panel to generate the sender'smodified code. The message sender sends a message with proposedmodifications corresponding to the sender's modified code. In this case,a function, such as “Show Diff,” is configured to trigger the system todisplay a code difference view in the user's editing panel between theoriginal code and a modified version of the original code with theproposed modifications executed. According to one embodiment, the “ShowDiff” function is configured to determine a set of differences betweenthe original code and the sender's modified code (and/or the proposedmodifications) and execute the proposed modifications on the originalcode based on the set of differences. Other described functions may besimilarly configured to compare the original code and a modified versionof the original code with the proposed modifications executed.

According to one embodiment, the user or message recipient modifies theoriginal code to generate the recipient's modified code. The messagesender also modifies the original code in his editing panel to generatethe sender's modified code. The message sender sends a message withproposed modifications corresponding to the sender's modified code. Inthis case, a function, such as “Show Diff.” is configured to trigger thesystem to display a code difference view in the user's editing panelbetween the recipient's modified code and a version of the recipient'smodified code with the proposed modifications executed. In order tocorrectly apply the proposed modifications, the system needs toaccommodate for concurrency issues arising from both the messagerecipient and the message sender having modified the original code intheir respective editing panels. According to one embodiment, the “ShowDiff” function is configured to determine a first set of differencesbetween the original code and the sender's modified code (and/or theproposed modifications), determine a second set of differences betweenthe recipient's modified code and the first set of differences, andexecute the proposed modifications on the recipient's modified codebased on the second set of differences. For example, a variable may beassigned a value X in the original code, a value Y in the recipient'smodified code, and a value Z in the sender's modified code. The systemexecuting the “Show Diff” function may determine that the first set ofdifferences includes an indication that the variable is assigned value Xin the original code and is to be changed to value Z from the sender'smodified code (and/or the proposed modifications). The system may thendetermine that the second set of differences includes an indication thatthe variable is assigned value Y in the recipient's modified code and isto be changed to value Z from the first set of differences. The systemmay then execute the proposed modifications on the recipient's modifiedcode based on the second set of differences and change the assignedvalue of the variable from Y to Z. The system may then display a codedifference view in the user's editing panel between the recipient'smodified code and this version of the recipient's modified code with theproposed modifications executed.

The systems and methods described are equally applicable to systems withmore than two users. Concurrency issues between the message recipient'scode and the message sender's code, such as those described above, maybe magnified as the system is scaled to incorporate more than two users.Moreover, each user may be associated with multiple versions of code,including a version being edited in real time (or a live copy), aversion saved locally (or a saved copy), and a version saved remotely(or a committed copy). The systems and methods described can accommodatea system with multiple users, each associated with multiple versions ofthe code. For example, the described systems and methods may scale up tothousands of users, each associated with one or more versions of thesame code. FIG. 17 and the related description below describe anillustrative algorithm to address the case with two users, eachassociated with three versions of the code.

FIG. 14 illustrates an example UI 1400 showing the result of selectingthe “Show Diff” function. The system displays a code difference view inthe editing panel 1304 where code 1408 from the message recipient(corresponding to the original code 1308) and the sender's modified code1409 from the message sender are shown. The code difference view mayshow changes to the code in markup language. The communication panel1306 may include a function “Hide Diff” at 1422, which triggers thesystem to return to the code view in the editing panel 1304 as shown inFIG. 13 . Additionally or alternatively, the user may select in the UI1400 from an option for the function to apply patch 1324, an option forthe function to copy code 1326, or an option for the function to warp1320 to the editing panel for another user, e.g., the sender of themessage 1301.

FIG. 15 illustrates an example UI 1500 showing the result of selectingthe “Apply Patch” function. When option 1324 is selected, the system isconfigured to accept the proposed code change detailed in the message1301 shown in the communication panel 1306 and generate a newvisualization of the code being visualized by the current user ormessage recipient (e.g., the recipient's modified code 1508) withchanges introduced. For example, the system may automatically determinethat the original code 1308 corresponds to the proposed code change inthe message 1301, receive identifying information for the original code1308 from the sender of the message 1301, or receive manualidentification of the original code 1308 from the user or recipient ofthe message 1301. Subsequent to identification of the correspondingcode, the system may replace the original code 1308 with the code fromthe message 1301 to generate the recipient's modified code 1508.Alternatively, the system may identify the differences between the code1301 and the proposed code change and replace the portions of code 1301that differ from the proposed code change. Additionally oralternatively, the communication panel 1306 may include a function“Revert” 1524, which triggers the system to revert the code to theversion prior to applying the proposed code change from the message 1301in the communication panel 1306. e.g., the original code 1308.

In conjunction, post, or prior to applying the proposed code change tothe original code 1308 in one of the manners described above, the systemmay save metadata corresponding to the original code 1308 where thesystem may include one or more indications of this version of theoriginal code 1308. For example, the system may store changes made tothe original code 1308 or the entirety of the original code 1308 in themetadata along with identifying information for retrieving it at a latertime (e.g., time, date, code file, commit identification and/or othersuitable identifying information). When the user selects option 1524 torevert the code prior to the proposed code change being applied to theoriginal code 1308, the system may retrieve the necessary informationfrom the metadata to replace the recipient's modified code 1508 with theoriginal code 1308.

FIG. 16 illustrates an example UI 1600 showing the result of selectingthe warp function. Selecting the warp function may allow the messagerecipient to compare his version of the code 1608 in editing panel 1602with the message sender's version of the code 1609 in editing panel1603. For example, the sender of the message 1301 may be identified as“Larry Wall,” and on selection of option 1320 to “Warp to Larry.” thesystem may generate editing panel 1602 with code 1608 (corresponding tothe original code 1308) and editing panel 1603 with code 1609(corresponding to the sender's modified code 1409). In this illustrativeexample, the user or recipient can view his version of the code, e.g.,code 1608, in one half of the screen and the message sender's code inthe other half of the screen, e.g., code 1609. Differences in code 1608and code 1609 may be shown using annotation visual elements, e.g., usingmarkup language.

FIG. 17 is an example process flow 1700 for determining one or moredifferences between live copies of a codeblock. According to oneembodiment, two users. A and B, may each have a live copy of a codeblockdisplayed on their respective systems. The live copy refers to one ormore lines of code or a code file that include code that may have beenmodified but not yet saved to a local storage device. The live copy ofthe codeblock may also be referred to as the visualized instance of thecodeblock. The live copy is a version of the codeblock that may differfrom a saved copy, which may in turn differ from a committed copy of thecodeblock. The saved copy refers to one or more lines of code or a codefile that include code that may have been modified and saved to a localstorage device but not yet committed to a remote storage device. e.g., acode repository. The saved copy of the codeblock may also be referred toas the local instance of the codeblock. The committed copy refers to oneor more lines of code or a code file stored in a remote storage device,e.g., a code repository. The committed copy may additionally beclassified as belonging a particular version stored in the coderepository. The committed copy of the codeblock may also be referred toas the remote instance of the codeblock.

In one embodiment, determining one or more differences. e.g., acrosslive copies of the codeblock for users A and B, requires analyzing andcomparing the live copy, the saved copy and/or the committed copy of thecodeblock for user A and the live copy, the saved copy and/or thecommitted copy of the codeblock for user B. In some examples, the systemcan maintain metadata information on changes made locally to code on auser system and compare metadata information on multiple users systemsto determine any changes.

According to one aspect, given the complexity of determiningdifferences, e.g., across live copies of the codeblock for users A andB, the system is augmented to resolve these complex comparisons based onexecuting a difference engine. In one embodiment, the difference enginecan be configured to execute the process flow described with respect toFIG. 17 . In various embodiments, the difference engine is configured tomanage code changes dynamically over time and between users. In otherembodiments, the system can execute the same functions with or withoutinstantiating a difference engine.

In one embodiment, the difference engine stores metadata that isassociated with a code change and that details a codeblock associatedwith the code change. The difference engine preserves an association tothe codeblock. The difference engine can be configured to generateand/or maintain the associations to codeblocks open on a computer as alive copy, preserved as saved copy, a committed copy, or anothersuitable version of the codeblock that can be modified (e.g., additionalcode added, deleted, renumbered, moved). The preservation may includereassigning the codeblock to include new code, deleted old code, ormoved old code. In one embodiment, the difference engine identifies oneor more differences between the visualized instance of the codeblock,associated with user A, and another instance of the codeblock,associated with user B. The difference engine may initiate theidentification by determining, based on the metadata, whether thevisualized instance of codeblock (e.g., a live copy) has been modifiedsubsequent to storage of a local instance of the first version. Furtherdetails are provided below.

Referring to FIG. 17 , in this illustrative embodiment, the live copiesof the codeblock for users A and B (live copy A, 1702; live copy B 1704)are compared to determine if there are any differences present acrossthe live copies. Initially, the live copy of the codeblock for user B(live copy B, 1704) is compared with a saved copy of the codeblock foruser B (saved copy B. 1706). If it is determined that live copy B hasbeen modified since saved copy B was last stored in local storage, afirst set of differences between saved copy B and live copy B isdetermined (e.g., accounting for differences between saved copy B andlive copy B). For example, the difference engine may compare eachcorresponding line of live copy B and saved copy B to determine thelines that have changed across the two copies. In another example, thedifference engine may employ a heuristic-based searched algorithm todetermine common portions between saved copy B and live copy B andsubsequently compare the remaining portions to determine the first setof differences. If it is determined that live copy B has not beenmodified since saved copy B was last stored in local storage (e.g., livecopy B has not been edited since last saved copy B), the next step inprocess flow 1700 may be executed.

Next, the saved copy of the codeblock for user B (saved copy B. 1706) iscompared with a committed copy of the codeblock for user B (committedcopy B, 1708). If it is determined that saved copy B has been modifiedsince committed copy B was last stored in remote storage, a second setof differences between committed copy B and the first set of differencesis determined (e.g., accounting for differences between committed copy Band saved copy B). If it is determined that saved copy B has not beenmodified since committed copy B was last stored in remote storage, thenext step in process flow 1700 may be executed.

Next, the committed copy of the codeblock for user B (committed copy B,1708) is compared with a committed copy of the codeblock for user A(committed copy A, 1710). If it is determined that committed copy B doesnot correspond to committed copy A, a third set of differences betweencommitted copy A and the second set of differences is determined (e.g.,accounting for differences in both committed copies because they belongto different control versions in a code repository). If it is determinedthat committed copy B corresponds to committed copy A (e.g., bothcommitted copies belong to the same control version in a coderepository), the next step in process flow 1700 may be executed.

Next, the committed copy of the codeblock for user A (committed copy A.1710) is compared with a saved copy of the codeblock for user A (savedcopy A, 1712). If it is determined that saved copy A has been modifiedsince committed copy A was last stored in remote storage, a fourth setof differences between saved copy A and the third set of differences isdetermined (e.g., accounting for differences between committed copy Aand saved copy A). If it is determined that saved copy A has not beenmodified since committed copy A was last stored in remote storage (e.g.,saved copy A has not been edited since last committed copy A), the nextstep in process flow 1700 may be executed.

Next, the saved copy of the codeblock for user A (saved copy A. 1712) iscompared with a live copy of the codeblock for user A (live copy A.1702). If it is determined that live copy A has been modified sincesaved copy A was last stored in local storage, a fifth set ofdifferences between live copy A and the fourth set of differences isdetermined (e.g., accounting for differences between saved copy A andlive copy A). If it is determined that live copy A has not been modifiedsince saved copy A was last stored in remote storage (e.g., live copy Ahas not been edited since last saved copy A), the next step in processflow 1700 may be executed.

If no differences are identified across all comparisons described above,an indication is generated for display notifying the user that nodifferences have been identified between live copy A and live copy B. Ifone or more differences are identified across one or more of thecomparisons described above, an indication is generated for displaynotifying the user that one or more differences have been identifiedbetween live copy A and live copy B. In one embodiment, a user interfacepanel is generated to display the one or more differences between thelive copy of the codeblock for user A and the live copy of the codeblockfor user B. The differences may be generated for displayed in the userinterface panel based on the fifth set of differences. Alternatively, ifthe fifth set of differences was not determined (e.g., because therewere no differences identified in the corresponding step), the fourthset of differences may be used for generating the display, and so on.Moreover, though the illustrated example is discussed with respect tolive copies of the codeblock for different users, the systems andmethods described are equally applicable to identifying differencesacross live copies, saved copies, committed copies, or other suitableversions of a codeblock for different users.

In one embodiment, when generating for display in the user interfacepanel the one or more differences, one or both of the live copies of thecodeblock for users A and B are displayed. Additionally, each differencebetween the live copies may be annotated in the user interface panel fordisplay to the user. For example, the annotations may be determinedbased on the fifth set of differences or another suitable set from thecomparisons described above. In one embodiment, the user interface panelmay generate, for display to user A, an apply function (e.g., applypatch) to change the live copy of the codeblock for user A to conformwith the live copy of the codeblock for user B. Additionally, the userinterface panel may generate, for display to user A, a revert function(e.g., revert patch) to revert to the visualized instance of the firstversion of the codeblock. In one embodiment, the user interface panelmay generate, for display to user B, an apply function (e.g., applypatch) to change the live copy of codeblock for user B to conform withthe live copy of the codeblock for user A. Additionally, the userinterface panel may generate, for display to user B, a revert function(e.g., revert patch) to revert to the visualized instance of the firstversion of the codeblock.

According to one embodiment, a communication system can include one ormore APIs for integrating VCS applications or services, as well as APIsfor maintain IDE functionality and real time communication channels incloud provided resources.

Further, various examples may be implemented as programmed ornon-programmed elements, or any combination thereof. For example, a webpage may be implemented using HTML while a data object called fromwithin the web page may be written in C++. Thus, the examples are notlimited to a specific programming language and any suitable programminglanguage could be used. Accordingly, the functional components disclosedherein may include a wide variety of elements, e.g., specializedhardware, executable code, data structures or data objects, that areconfigured to perform the functions described herein.

Having thus described several aspects of at least one example, it is tobe appreciated that various alterations, modifications, and improvementswill readily occur to those skilled in the art. For instance, examplesdisclosed herein may also be used in other contexts. Such alterations,modifications, and improvements are intended to be part of thisdisclosure, and are intended to be within the scope of the examplesdiscussed herein. Accordingly, the foregoing description and drawingsare by way of example only.

Use of ordinal terms such as “first,” “second,” “third,” “a,” “b,” “c,”etc., in the claims to modify or otherwise identify a claim element doesnot by itself connote any priority, precedence, or order of one claimelement over another or the temporal order in which acts of a method areperformed, but are used merely as labels to distinguish one claimelement having a certain name from another element having a same name(but for use of the ordinal term) to distinguish the claim elements.

What is claimed is:
 1. A communication system for augmenting a software development environment, the system comprising one or more processers configured to perform the operations of: generating a communication panel in conjunction with a code editing panel, wherein the communication panel is configured to display a message stream of user based communication associated with code displayed in the code editing panel; displaying a communication interface providing a text input section for receiving text input for the user based communication, wherein the user based communication accepted by the communication interface is associated with a codeblock and a reference to the codeblock is embedded into the user based communication; receiving a modification of the code in the code editing panel, wherein the modification comprises the addition of code, deletion of code, renumbering of code, and/or moving of code; and in response to receiving the modification, storing metadata for preserving communication thread linkage between modified code and the message stream associated with the code in the code editing panel, wherein the metadata comprises information associated with the location of the code file, location of the code line, position of the code line, number of code lines, message streams and/or user based communications. 2-20. (canceled) 